home *** CD-ROM | disk | FTP | other *** search
/ Trading on the Edge / Trading On The Edge - CD-ROM Toolkit (Wayzata Technology)(2031)(1994).bin / pc / shared / freeman / elman.m < prev    next >
Text File  |  1993-10-27  |  8KB  |  170 lines
  1. BeginPackage["Elman`"]
  2.  
  3.  
  4. elman::usage = "elman[inNumber,hidNumber,outNumber,ioPairs,eta,alpha,numIters]"
  5. elmanTest::usage = "elmanTest[hiddenWts,outputWts,ioPairVectors,conNumber,printAll:False]"
  6. elmanComp::usage = "elmanComp[inNumber,hidNumber,outNumber,ioPairs,eta,alpha,numIters]"
  7. elmanCompTest::usage = "elmanCompTest[hiddenWts,outputWts,ioPairVectors,conNumber,printAll:False]"
  8.  
  9.  
  10. Begin["`Private`"]    (* begin the private context *)
  11.  
  12. elman[inNumber_,hidNumber_,outNumber_,ioPairs_,eta_,alpha_,numIters_] :=
  13.   Module[{hidWts,outWts,ioP,inputs,hidOuts,outputs,outDesired, 
  14.             i,indx,hidLastDelta,outLastDelta,outDelta,errorList={},
  15.             ioSequence, conUnits,hidDelta,outErrors},
  16.   hidWts = Table[Table[Random[Real,{-0.5,0.5}],{inNumber+hidNumber}],{hidNumber}];
  17.   outWts = Table[Table[Random[Real,{-0.5,0.5}],{hidNumber}],{outNumber}];
  18.   hidLastDelta = Table[Table[0,{inNumber+hidNumber}],{hidNumber}];
  19.   outLastDelta = Table[Table[0,{hidNumber}],{outNumber}];
  20.   For[indx=1,indx<=numIters,indx++,  (* begin forward pass; select a sequence  *)
  21.     ioSequence=ioPairs[[Random[Integer,{1,Length[ioPairs]}]]];
  22.     conUnits = Table[0.5,{hidNumber}];     (* reset conUnits  *)
  23.     For[i=1,i<=Length[ioSequence],i++,      (* process the sequence in order *)
  24.    ioP = ioSequence[[i]];                (* pick out the next ioPair *)
  25.    inputs=Join[conUnits,ioP[[1]] ];      (* join context and input units *)
  26.       outDesired=ioP[[2]];
  27.       hidOuts = sigmoid[hidWts.inputs];     (* hidden-layer outputs *)
  28.       outputs = sigmoid[outWts.hidOuts];    (* output-layer outputs *)
  29.       outErrors = outDesired-outputs;       (* calculate errors *)
  30.       outDelta= outErrors (outputs (1-outputs));
  31.       hidDelta=(hidOuts (1-hidOuts)) Transpose[outWts].outDelta;
  32.       outLastDelta= eta Outer[Times,outDelta,hidOuts]+alpha outLastDelta;
  33.       outWts += outLastDelta;               (* update weights *)
  34.       hidLastDelta = eta Outer[Times,hidDelta,inputs]+alpha hidLastDelta;
  35.       hidWts += hidLastDelta;
  36.       conUnits = hidOuts;                   (* update context units *)
  37.          (* put the sum of the squared errors on the list *)
  38.       AppendTo[errorList,outErrors.outErrors];
  39.       ]; (* end of For i *)
  40.   ];     (* end of For indx *)
  41.   Print["New hidden-layer weight matrix: "];
  42.   Print[ ]; Print[hidWts];Print[ ];
  43.   Print["New output-layer weight matrix: "];
  44.   Print[ ]; Print[outWts];Print[ ];  
  45.   elmanTest[hidWts,outWts,ioPairs,hidNumber];  
  46.   errorPlot = ListPlot[errorList, PlotJoined->True];
  47.   Return[{hidWts,outWts,errorList,errorPlot}];
  48.   ]                        (* end of Module *)
  49.  
  50.  
  51.  
  52. elmanTest[hiddenWts_,outputWts_,ioPairVectors_,conNumber_,printAll_:False] :=
  53.   Module[{inputs,hidden,outputs,desired,errors,i,j,
  54.               prntAll,conUnits,ioSequence,ioP},
  55.     If[printAll,Print[];Print["ioPairs:"];Print[];Print[ioPairVectors]];
  56.                  (* loop through the sequences  *)
  57.        For[i=1,i<=Length[ioPairVectors],i++,
  58.                  (* select the next sequence *)
  59.      ioSequence = ioPairVectors[[i]];
  60.                  (* reset the context units  *)
  61.      conUnits = Table[0.5,{conNumber}];
  62.                  (* loop through the chosen sequence *)
  63.          For[j=1,j<=Length[ioSequence],j++,
  64.               ioP = ioSequence[[j]];
  65.                     (* join context and input units *)
  66.               inputs=Join[conUnits,ioP[[1]] ];
  67.                desired=ioP[[2]];
  68.                hidden=sigmoid[hiddenWts.inputs];
  69.                outputs=sigmoid[outputWts.hidden];
  70.                errors= desired-outputs;
  71.                    (* update context units *)
  72.                conUnits = hidden;
  73.                Print[];
  74.                Print["Sequence ",i, " input ",j];
  75.                Print[];Print["inputs:"];Print[];
  76.                Print[inputs];
  77.                If[printAll,Print[];Print["hidden-layer outputs:"];
  78.                    Print[hidden];Print[];
  79.                    ];
  80.                Print["outputs:"];Print[];
  81.                Print[outputs];Print[];
  82.                Print["desired:"];Print[];Print[desired];Print[];
  83.                Print["Mean squared error:"];
  84.                Print[errors.errors/Length[errors]];
  85.                Print[];
  86.                ];  (* end of For j *)
  87.             ];    (* end of For i *)
  88.     ]                    (* end of Module *)
  89.  
  90.  
  91. elmanComp[inNumber_,hidNumber_,outNumber_,ioPairs_,eta_,alpha_,numIters_] :=
  92.   Module[{hidWts,outWts,ioP,inputs,hidOuts,outputs,outDesired, 
  93.             i,indx,hidLastDelta,outLastDelta,outDelta,errorList={}, 
  94.             ioSequence, conUnits,hidDelta,outErrors},
  95.   hidWts = Table[Table[Random[Real,{-0.5,0.5}],{inNumber+conNumber}],{hidNumber}];
  96.   outWts = Table[Table[Random[Real,{-0.5,0.5}],{hidNumber}],{outNumber}];
  97.   hidLastDelta = Table[Table[0,{inNumber+conNumber}],{hidNumber}];
  98.   outLastDelta = Table[Table[0,{hidNumber}],{outNumber}];
  99.   outErrors = Table[0,{outNumber}];
  100.   For[indx=1,indx<=numIters,indx++,
  101.     ioSequence=ioPairs[[Random[Integer,{1,Length[ioPairs]}]]]; (* select a sequence  *)
  102.     conUnits = Table[0.5,{conNumber}];       (* reset conUnits  *)
  103.     For[i=1,i<=Length[ioSequence],i++,       (* process the sequence in order *)
  104.       ioP = ioSequence[[i]];                 (* pick out the next ioPair *)
  105.       inputs=Join[conUnits,ioP[[1]] ];       (* join context and input units *)
  106.       outDesired=ioP[[2]];
  107.       hidOuts = sigmoid[hidWts.inputs];      (* hidden-layer outputs *)
  108.       outputs = outWts.hidOuts;              (* output-layer outputs *)
  109.       outputs = sigmoid[outputs -    0.3 Apply[Plus,outputs] + .5 outputs]; 
  110.       outErrors = outDesired-outputs;        (* calculate errors *)
  111.       outDelta= outErrors (outputs (1-outputs));
  112.       hidDelta=(hidOuts (1-hidOuts)) Transpose[outWts].outDelta;
  113.       outLastDelta= eta Outer[Times,outDelta,hidOuts]+alpha outLastDelta;
  114.       outWts += outLastDelta;                 (* update weights *)
  115.       hidLastDelta = eta Outer[Times,hidDelta,inputs]+alpha hidLastDelta;
  116.       hidWts += hidLastDelta;                (* update weights *)
  117.       conUnits = hidOuts;                    (* update context units *)
  118.          (* put the sum of the squared errors on the list *)
  119.       AppendTo[errorList,outErrors.outErrors];
  120.       ]; (* end of For i *)
  121.   ];     (* end of For indx *)
  122.   Print["New hidden-layer weight matrix: "];
  123.   Print[ ]; Print[hidWts];Print[ ];
  124.   Print["New output-layer weight matrix: "];
  125.   Print[ ]; Print[outWts];Print[ ];  
  126.   elmanCompTest[hidWts,outWts,ioPairs,conNumber]; 
  127.   errorPlot = ListPlot[errorList, PlotJoined->True];
  128.   Return[{hidWts,outWts,errorList,errorPlot}];
  129.   ]                        (* end of Module *)
  130.  
  131.  
  132. elmanCompTest[hiddenWts_,outputWts_,ioPairVectors_,conNumber_,printAll_:False] :=
  133.   Module[{inputs,hidden,outputs,desired,errors,i,j,prntAll,conUnits,ioSequence,ioP},
  134.     If[printAll,Print[];Print["ioPairs:"];Print[];Print[ioPairVectors]];
  135.        For[i=1,i<=Length[ioPairVectors],i++,   (* loop through the sequences  *)
  136.      ioSequence = ioPairVectors[[i]];       (* select the next sequence *)
  137.      conUnits = Table[0.5,{conNumber}];     (* reset the context units  *)
  138.          For[j=1,j<=Length[ioSequence],j++,    (* loop through the chosen sequence *)
  139.               ioP = ioSequence[[j]];
  140.               inputs=Join[conUnits,ioP[[1]] ];       (* join context and input units *)
  141.                desired=ioP[[2]];
  142.                hidden=sigmoid[hiddenWts.inputs];
  143.                outputs=outputWts.hidden;
  144.                outputs=sigmoid[outputs - 
  145.                    0.3 Apply[Plus,outputs] + 0.5 outputs];
  146.                errors= desired-outputs;
  147.                    (* update context units *)
  148.                conUnits = hidden;
  149.                Print[];
  150.                Print["Sequence ",i, " input ",j];
  151.                Print[];Print["inputs:"];Print[];
  152.                Print[inputs];
  153.                If[printAll,Print[];Print["hidden-layer outputs:"];
  154.                    Print[hidden];Print[];
  155.                    ];
  156.                Print["outputs:"];Print[];
  157.                Print[outputs];Print[];
  158.                Print["desired:"];Print[];Print[desired];Print[];
  159.                Print["Mean squared error:"];
  160.                Print[errors.errors/Length[errors]];
  161.                Print[];
  162.                ];  (* end of For j *)
  163.             ];    (* end of For i *)
  164.     ]                    (* end of Module *)
  165.  
  166.  
  167.  
  168. End[]         (* end the private context *)
  169.  
  170. EndPackage[]  (* end the package context *)